/**
 * 将树形结构数据按主子关系排序
 * @param {Array} list - 原始数据列表，每个元素应包含 node_id 和 parent_id
 * @param {string|number|null} [rootParentId] - 可选参数，指定根节点的 parent_id 值
 * @return {Array} - 排序后的数组，保持树形结构顺序
 */
export function sortTreeList(list: any, rootParentId: any, treeConfig?: any): Array<any> {
  const keyField = treeConfig?.keyField || treeConfig?.rowField || 'node_id'
  const parentField = treeConfig?.parentField || 'parent_id'
  const orderField = treeConfig?.parentField || 'order'
  if (!list?.length) {
    return list
  }

  // 创建一个映射，以 parent_id 为键，存储对应的子节点数组
  const parentChildrenMap: Record<string, any[]> = {}

  // 初始化映射
  list.forEach((item: any) => {
    const parentId = item[parentField]
    if (!parentChildrenMap[parentId]) {
      parentChildrenMap[parentId] = []
    }
    parentChildrenMap[parentId].push(item)
  })

  // 递归排序函数
  function sortChildren(parentId: any) {
    const children: any[] = parentChildrenMap[parentId] || []

    // 对当前层级的节点进行排序（可以修改比较函数实现不同排序规则）
    children.sort((a: any, b: any) =>
      a[orderField] && b[orderField] ? a[orderField] - b[orderField] : 0
    ) // 按 order 排序

    // 递归处理每个子节点的子节点
    const result: any[] = []
    children.forEach((child: any) => {
      result.push(child)
      result.push(...sortChildren(child[keyField]))
    })

    return result
  }

  // 解析根 parent_id 列表
  let rootParentIds: any[] = []

  if (Array.isArray(rootParentId)) {
    // 显式传入了多个根 parent_id
    rootParentIds = rootParentId
  } else if (rootParentId !== undefined) {
    // 显式传入了单个根 parent_id
    rootParentIds = [rootParentId]
  } else {
    // 未传入 rootParentId，自动检测可能的根 parent_id（parent_id 不在所有 node_id 集合中）
    const allNodeIds = new Set(list.map((item: any) => item[keyField]))
    const candidateRoots = list.filter((item: any) => !allNodeIds.has(item[parentField]))

    if (candidateRoots.length === 0) {
      throw new Error('无法确定根节点：可能存在循环引用或数据不完整')
    }

    // 统计各候选根 parent_id 出现次数，并按出现次数降序（再按字面排序稳定）
    const parentIdCounts: Record<string, number> = {}
    candidateRoots.forEach((item: any) => {
      const key = item[parentField]
      parentIdCounts[key] = (parentIdCounts[key] || 0) + 1
    })

    rootParentIds = Object.entries(parentIdCounts).map(([pid]) => pid)
  }

  // 依次从每个根 parent_id 开始排序并拼接为扁平数组
  let result: any[] = []
  rootParentIds.forEach((pid) => {
    result = result.concat(sortChildren(pid))
  })

  return result
}

/**
 * 获取节点的父节点，直到找到具有className的节点，在container容器内查找
 * @param target
 * @param className
 * @param container
 * @returns
 */
export function getParentNode(target: any, className: any, container: any) {
  let targetElem: any
  while (target && target.nodeType && target !== document) {
    if (
      className &&
      target.className &&
      target.className.split &&
      target.className.split(' ').indexOf(className) > -1
    ) {
      targetElem = target
      return targetElem
    } else if (target === container) {
      return null
    }
    target = target.parentNode
  }
  return targetElem
}
